home *** CD-ROM | disk | FTP | other *** search
/ Aminet 43 / Aminet 43 (2001)(GTI - Schatztruhe)[!][Jun 2001].iso / Aminet / comm / mail / YAM22src.lha / YAM_rexx_rxif.c < prev    next >
C/C++ Source or Header  |  2000-11-03  |  63KB  |  2,327 lines
  1. /*
  2.  * Source generated with ARexxBox 1.12 (May 18 1993)
  3.  * which is Copyright (c) 1992,1993 Michael Balzer
  4.  */
  5.  
  6. #include <exec/types.h>
  7. #include <exec/memory.h>
  8. #include <dos/dos.h>
  9. #include <rexx/storage.h>
  10. #include <rexx/rxslib.h>
  11.  
  12. #ifdef __GNUC__
  13. /* GCC needs all struct defs */
  14. #include <dos/exall.h>
  15. #include <graphics/graphint.h>
  16. #include <intuition/classes.h>
  17. #include <devices/keymap.h>
  18. #include <exec/semaphores.h>
  19. #endif
  20.  
  21. #include <clib/alib_protos.h>
  22. #include <clib/exec_protos.h>
  23. #include <clib/dos_protos.h>
  24. #include <clib/rexxsyslib_protos.h>
  25.  
  26. #ifndef __NO_PRAGMAS
  27.  
  28. #ifdef AZTEC_C
  29. #include <pragmas/exec_lib.h>
  30. #include <pragmas/dos_lib.h>
  31. #include <pragmas/rexxsyslib_lib.h>
  32. #endif
  33.  
  34. #ifdef LATTICE
  35. #include <pragmas/exec_pragmas.h>
  36. #include <pragmas/dos_pragmas.h>
  37. #include <pragmas/rexxsyslib_pragmas.h>
  38. #endif
  39.  
  40. #endif /* __NO_PRAGMAS */
  41.  
  42. #include <stdlib.h>
  43. #include <stdio.h>
  44. #include <string.h>
  45. #include <ctype.h>
  46.  
  47. #ifdef LATTICE
  48. #undef toupper
  49. #define inline __inline
  50. #endif
  51.  
  52. #ifdef __GNUC__
  53. #undef toupper
  54. static inline char toupper( char c )
  55. {
  56.    return( islower(c) ? c - 'a' + 'A' : c );
  57. }
  58. #endif
  59.  
  60. #ifdef AZTEC_C
  61. #define inline
  62. #endif
  63.  
  64. #include "YAM_rexx.h"
  65.  
  66.  
  67. extern struct ExecBase *SysBase;
  68. extern struct DosLibrary *DOSBase;
  69. extern struct RxsLib *RexxSysBase;
  70.  
  71.  
  72. /* $ARB: I 876664321 */
  73.  
  74.  
  75. /* $ARB: B 1 SHOW */
  76. #include "YAM.h"
  77. /// OK
  78. void rx_show( struct RexxHost *host, struct rxd_show **rxd, long action, struct RexxMsg *rexxmsg )
  79. {
  80.    struct rxd_show *rd = *rxd;
  81.    switch( action )
  82.    {
  83.       case RXIF_INIT:
  84.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  85.          break;
  86.          
  87.       case RXIF_ACTION:
  88.          set(G->App, MUIA_Application_Iconified, FALSE);
  89.          break;
  90.       
  91.       case RXIF_FREE:
  92.          FreeVec( rd );
  93.          break;
  94.    }
  95.    return;
  96. }
  97. ///
  98. /* $ARB: E 1 SHOW */
  99.  
  100. /* $ARB: B 2 HIDE */
  101. /// OK
  102. void rx_hide( struct RexxHost *host, struct rxd_hide **rxd, long action, struct RexxMsg *rexxmsg )
  103. {
  104.    struct rxd_hide *rd = *rxd;
  105.    switch( action )
  106.    {
  107.       case RXIF_INIT:
  108.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  109.          break;
  110.          
  111.       case RXIF_ACTION:
  112.          set(G->App, MUIA_Application_Iconified, TRUE);
  113.          break;
  114.       
  115.       case RXIF_FREE:
  116.          FreeVec( rd );
  117.          break;
  118.    }
  119.    return;
  120. }
  121. ///
  122. /* $ARB: E 2 HIDE */
  123.  
  124. /* $ARB: B 3 QUIT */
  125. /// OK
  126. void rx_quit( struct RexxHost *host, struct rxd_quit **rxd, long action, struct RexxMsg *rexxmsg )
  127. {
  128.    struct rxd_quit *rd = *rxd;
  129.    switch( action )
  130.    {
  131.       case RXIF_INIT:
  132.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  133.          break;
  134.          
  135.       case RXIF_ACTION:
  136.          if (rd->arg.force) set(G->App, MUIA_Application_ForceQuit, TRUE);
  137.          DoMethod(G->App, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
  138.          break;
  139.       
  140.       case RXIF_FREE:
  141.          FreeVec( rd );
  142.          break;
  143.    }
  144.    return;
  145. }
  146. ///
  147. /* $ARB: E 3 QUIT */
  148.  
  149. /* $ARB: B 4 HELP */
  150. /// OK
  151. void rx_help( struct RexxHost *host, struct rxd_help **rxd, long action, struct RexxMsg *rexxmsg )
  152. {
  153.    struct rxd_help *rd = *rxd;
  154.    struct rxs_command *rxc;
  155.    FILE *fp = NULL, *out = stdout;
  156.    switch( action )
  157.    {
  158.       case RXIF_INIT:
  159.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  160.          break;
  161.          
  162.       case RXIF_ACTION:
  163.          if (rd->arg.file) if (fp = fopen(rd->arg.file, "w")) out = fp;
  164.          fprintf(out, "Commands for application \"YAM\"\n\nCommand          Template\n-------          --------\n");
  165.          for (rxc = rxs_commandlist; rxc->command; rxc++)
  166.             fprintf(out, "%-16s%c%s%s%s%s%s\n", rxc->command,
  167.                (rxc->results || rxc->args) ? ' ' : '\0', rxc->results ? "VAR/K,STEM/K" : "",
  168.                (rxc->results && rxc->args) ? "," : "", rxc->args ? rxc->args : "",
  169.                rxc->results ? " => " : "", rxc->results ? rxc->results : "");
  170.          if (fp) fclose(fp);
  171.          break;
  172.       
  173.       case RXIF_FREE:
  174.          FreeVec( rd );
  175.          break;
  176.    }
  177.    return;
  178. }
  179. ///
  180. /* $ARB: E 4 HELP */
  181.  
  182. /* $ARB: B 5 INFO */
  183. /// OK
  184. void rx_info( struct RexxHost *host, struct rxd_info **rxd, long action, struct RexxMsg *rexxmsg )
  185. {
  186.    struct rxd_info *rd = *rxd;
  187.    char *key;
  188.    switch( action )
  189.    {
  190.       case RXIF_INIT:
  191.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  192.          break;
  193.          
  194.       case RXIF_ACTION:
  195.          key = rd->arg.item;
  196.          if      (!stricmp(key, "title"))       get(G->App, MUIA_Application_Title, &rd->res.value);
  197.          else if (!stricmp(key, "author"))      get(G->App, MUIA_Application_Author, &rd->res.value);
  198.          else if (!stricmp(key, "copyright"))   get(G->App, MUIA_Application_Copyright, &rd->res.value);
  199.          else if (!stricmp(key, "description")) get(G->App, MUIA_Application_Description, &rd->res.value);
  200.          else if (!stricmp(key, "version"))     get(G->App, MUIA_Application_Version, &rd->res.value);
  201.          else if (!stricmp(key, "base"))        get(G->App, MUIA_Application_Base, &rd->res.value);
  202.          else if (!stricmp(key, "screen"))
  203.          {
  204.             struct Screen *screen;
  205.             struct Node *pubs;
  206.             struct List *pubscreens = LockPubScreenList();
  207.             rd->res.value = "";
  208.             get(G->MA->GUI.WI, MUIA_Window_Screen, &screen);
  209.             for (pubs = pubscreens->lh_Head; pubs->ln_Succ; pubs = pubs->ln_Succ)
  210.                if (((struct PubScreenNode *)pubs)->psn_Screen == screen) rd->res.value = pubs->ln_Name;
  211.             UnlockPubScreenList();
  212.          }
  213.          else rd->rc = RETURN_ERROR;
  214.          break;
  215.       
  216.       case RXIF_FREE:
  217.          FreeVec( rd );
  218.          break;
  219.    }
  220.    return;
  221. }
  222. ///
  223. /* $ARB: E 5 INFO */
  224.  
  225. /* $ARB: B 6 WRITETO */
  226. /// OK
  227. void rx_writeto( struct RexxHost *host, struct rxd_writeto **rxd, long action, struct RexxMsg *rexxmsg )
  228. {
  229.    struct rxd_writeto *rd = *rxd;
  230.    switch( action )
  231.    {
  232.       case RXIF_INIT:
  233.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  234.          break;
  235.          
  236.       case RXIF_ACTION:
  237.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_TO, rd->arg.address, rd->arg.add);
  238.          else rd->rc = RETURN_ERROR;
  239.          break;
  240.       
  241.       case RXIF_FREE:
  242.          FreeVec( rd );
  243.          break;
  244.    }
  245.    return;
  246. }
  247. ///
  248. /* $ARB: E 6 WRITETO */
  249.  
  250. /* $ARB: B 7 WRITECC */
  251. /// OK
  252. void rx_writecc( struct RexxHost *host, struct rxd_writecc **rxd, long action, struct RexxMsg *rexxmsg )
  253. {
  254.    struct rxd_writecc *rd = *rxd;
  255.    switch( action )
  256.    {
  257.       case RXIF_INIT:
  258.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  259.          break;
  260.          
  261.       case RXIF_ACTION:
  262.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_CC, rd->arg.address, rd->arg.add);
  263.          else rd->rc = RETURN_ERROR;
  264.          break;
  265.       
  266.       case RXIF_FREE:
  267.          FreeVec( rd );
  268.          break;
  269.    }
  270.    return;
  271. }
  272. ///
  273. /* $ARB: E 7 WRITECC */
  274.  
  275. /* $ARB: B 8 WRITEBCC */
  276. /// OK
  277. void rx_writebcc( struct RexxHost *host, struct rxd_writebcc **rxd, long action, struct RexxMsg *rexxmsg )
  278. {
  279.    struct rxd_writebcc *rd = *rxd;
  280.    switch( action )
  281.    {
  282.       case RXIF_INIT:
  283.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  284.          break;
  285.          
  286.       case RXIF_ACTION:
  287.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_BCC, rd->arg.address, rd->arg.add);
  288.          else rd->rc = RETURN_ERROR;
  289.          break;
  290.       
  291.       case RXIF_FREE:
  292.          FreeVec( rd );
  293.          break;
  294.    }
  295.    return;
  296. }
  297. ///
  298. /* $ARB: E 8 WRITEBCC */
  299.  
  300. /* $ARB: B 9 WRITEATTACH */
  301. /// OK
  302. void rx_writeattach( struct RexxHost *host, struct rxd_writeattach **rxd, long action, struct RexxMsg *rexxmsg )
  303. {
  304.    struct rxd_writeattach *rd = *rxd;
  305.    switch( action )
  306.    {
  307.       case RXIF_INIT:
  308.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  309.          break;
  310.          
  311.       case RXIF_ACTION:
  312.          if (access(rd->arg.file,F_OK) == 0 && G->WR[G->ActiveWriteWin])
  313.          {
  314.             WR_AddFileToList(G->ActiveWriteWin, rd->arg.file, NULL, FALSE);
  315.             if (rd->arg.desc)    setstring(G->WR[G->ActiveWriteWin]->GUI.ST_DESC, rd->arg.desc);
  316.             if (rd->arg.encmode) setmutex (G->WR[G->ActiveWriteWin]->GUI.RA_ENCODING, !strnicmp(rd->arg.encmode, "uu", 2) ? 1 : 0);
  317.             if (rd->arg.ctype)   setstring(G->WR[G->ActiveWriteWin]->GUI.ST_CTYPE, rd->arg.ctype);
  318.          }
  319.          else rd->rc = RETURN_ERROR;
  320.          break;
  321.       
  322.       case RXIF_FREE:
  323.          FreeVec( rd );
  324.          break;
  325.    }
  326.    return;
  327. }
  328. ///
  329. /* $ARB: E 9 WRITEATTACH */
  330.  
  331. /* $ARB: B 10 WRITELETTER */
  332. /// OK
  333. void rx_writeletter( struct RexxHost *host, struct rxd_writeletter **rxd, long action, struct RexxMsg *rexxmsg )
  334. {
  335.    struct rxd_writeletter *rd = *rxd;
  336.    switch( action )
  337.    {
  338.       case RXIF_INIT:
  339.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  340.          break;
  341.          
  342.       case RXIF_ACTION:
  343.          if (G->WR[G->ActiveWriteWin]) if (CopyFile(G->WR_Filename[G->ActiveWriteWin], 0, rd->arg.file, 0))
  344.          {
  345.             if (C->UseSignature && !rd->arg.nosig) WR_AddSignature(G->WR_Filename[G->ActiveWriteWin], -1);
  346.             FileToEditor(G->WR_Filename[G->ActiveWriteWin], G->WR[G->ActiveWriteWin]->GUI.TE_EDIT);
  347.          }
  348.          else rd->rc = RETURN_ERROR;  else rd->rc = RETURN_ERROR;
  349.          break;
  350.       
  351.       case RXIF_FREE:
  352.          FreeVec( rd );
  353.          break;
  354.    }
  355.    return;
  356. }
  357. ///
  358. /* $ARB: E 10 WRITELETTER */
  359.  
  360. /* $ARB: B 11 WRITEOPTIONS */
  361. /// OK
  362. void rx_writeoptions( struct RexxHost *host, struct rxd_writeoptions **rxd, long action, struct RexxMsg *rexxmsg )
  363. {
  364.    struct rxd_writeoptions *rd = *rxd;
  365.    switch( action )
  366.    {
  367.       case RXIF_INIT:
  368.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  369.          break;
  370.          
  371.       case RXIF_ACTION:
  372.          if (G->WR[G->ActiveWriteWin])
  373.          {
  374.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_DELSEND, rd->arg.delete);
  375.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_RECEIPT, rd->arg.receipt);
  376.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_DISPNOTI, rd->arg.notif);
  377.             setcheckmark(G->WR[G->ActiveWriteWin]->GUI.CH_ADDINFO, rd->arg.addinfo);
  378.             if (rd->arg.importance) setcycle(G->WR[G->ActiveWriteWin]->GUI.CY_IMPORTANCE, *rd->arg.importance);
  379.             if (rd->arg.sig)        setmutex(G->WR[G->ActiveWriteWin]->GUI.RA_SIGNATURE, *rd->arg.sig);
  380.             if (rd->arg.security)   setmutex(G->WR[G->ActiveWriteWin]->GUI.RA_SECURITY, *rd->arg.security);
  381.          }
  382.          else rd->rc = RETURN_ERROR;
  383.          break;
  384.       
  385.       case RXIF_FREE:
  386.          FreeVec( rd );
  387.          break;
  388.    }
  389.    return;
  390. }
  391. ///
  392. /* $ARB: E 11 WRITEOPTIONS */
  393.  
  394. /* $ARB: B 12 WRITEQUEUE */
  395. /// OK
  396. void rx_writequeue( struct RexxHost *host, struct rxd_writequeue **rxd, long action, struct RexxMsg *rexxmsg )
  397. {
  398.    struct rxd_writequeue *rd = *rxd;
  399.    switch( action )
  400.    {
  401.       case RXIF_INIT:
  402.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  403.          break;
  404.          
  405.       case RXIF_ACTION:
  406.          WR_NewMail(rd->arg.hold ? WRITE_HOLD : WRITE_QUEUE, G->ActiveWriteWin);
  407.          break;
  408.       
  409.       case RXIF_FREE:
  410.          FreeVec( rd );
  411.          break;
  412.    }
  413.    return;
  414. }
  415. ///
  416. /* $ARB: E 12 WRITEQUEUE */
  417.  
  418. /* $ARB: B 13 WRITESEND */
  419. /// OK
  420. void rx_writesend( struct RexxHost *host, struct rxd_writesend **rxd, long action, struct RexxMsg *rexxmsg )
  421. {
  422.    struct rxd_writesend *rd = *rxd;
  423.    switch( action )
  424.    {
  425.       case RXIF_INIT:
  426.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  427.          break;
  428.          
  429.       case RXIF_ACTION:
  430.          WR_NewMail(WRITE_SEND, G->ActiveWriteWin);
  431.          break;
  432.       
  433.       case RXIF_FREE:
  434.          FreeVec( rd );
  435.          break;
  436.    }
  437.    return;
  438. }
  439. ///
  440. /* $ARB: E 13 WRITESEND */
  441.  
  442. /* $ARB: B 14 MAILWRITE */
  443. /// OK
  444. void rx_mailwrite( struct RexxHost *host, struct rxd_mailwrite **rxd, long action, struct RexxMsg *rexxmsg )
  445. {
  446.    struct rxd_mailwrite *rd = *rxd;
  447.    int winnr;
  448.    switch( action )
  449.    {
  450.       case RXIF_INIT:
  451.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  452.          break;
  453.          
  454.       case RXIF_ACTION:
  455.          winnr = rd->arg.window ? *rd->arg.window : -1;
  456.          rd->res.window = &G->ActiveWriteWin;
  457.          if (winnr < 0)
  458.          {
  459.             if ((winnr = MA_NewMessage(NEW_NEW, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  460.             else rd->rc = RETURN_ERROR;
  461.          }
  462.          else
  463.          {
  464.             if (winnr >= 0 && winnr <= 1) if (G->WR[winnr]) G->ActiveWriteWin = winnr;
  465.             else rd->rc = RETURN_ERROR;
  466.          }
  467.          break;
  468.       
  469.       case RXIF_FREE:
  470.          FreeVec( rd );
  471.          break;
  472.    }
  473.    return;
  474. }
  475. ///
  476. /* $ARB: E 14 MAILWRITE */
  477.  
  478. /* $ARB: B 15 MAILREPLY */
  479. /// OK
  480. void rx_mailreply( struct RexxHost *host, struct rxd_mailreply **rxd, long action, struct RexxMsg *rexxmsg )
  481. {
  482.    struct rxd_mailreply *rd = *rxd;
  483.    int winnr;
  484.    switch( action )
  485.    {
  486.       case RXIF_INIT:
  487.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  488.          break;
  489.          
  490.       case RXIF_ACTION:
  491.          rd->res.window = &G->ActiveWriteWin;
  492.          if ((winnr = MA_NewMessage(NEW_REPLY, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  493.          else rd->rc = RETURN_ERROR;
  494.          break;
  495.       
  496.       case RXIF_FREE:
  497.          FreeVec( rd );
  498.          break;
  499.    }
  500.    return;
  501. }
  502. ///
  503. /* $ARB: E 15 MAILREPLY */
  504.  
  505. /* $ARB: B 16 MAILFORWARD */
  506. /// OK
  507. void rx_mailforward( struct RexxHost *host, struct rxd_mailforward **rxd, long action, struct RexxMsg *rexxmsg )
  508. {
  509.    struct rxd_mailforward *rd = *rxd;
  510.    int winnr;
  511.  
  512.    switch( action )
  513.    {
  514.       case RXIF_INIT:
  515.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  516.          break;
  517.          
  518.       case RXIF_ACTION:
  519.          rd->res.window = &G->ActiveWriteWin;
  520.          if ((winnr = MA_NewMessage(NEW_FORWARD, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  521.          else rd->rc = RETURN_ERROR;
  522.          break;
  523.       
  524.       case RXIF_FREE:
  525.          FreeVec( rd );
  526.          break;
  527.    }
  528.    return;
  529. }
  530. ///
  531. /* $ARB: E 16 MAILFORWARD */
  532.  
  533. /* $ARB: B 17 MAILMOVE */
  534. /// OK
  535. void rx_mailmove( struct RexxHost *host, struct rxd_mailmove **rxd, long action, struct RexxMsg *rexxmsg )
  536. {
  537.    struct rxd_mailmove *rd = *rxd;
  538.    struct Folder *folder;
  539.    switch( action )
  540.    {
  541.       case RXIF_INIT:
  542.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  543.          break;
  544.          
  545.       case RXIF_ACTION:
  546.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL))
  547.             MA_MoveCopy(NULL, FO_GetCurrentFolder(), folder, FALSE);
  548.          else rd->rc = RETURN_ERROR;
  549.          break;
  550.       
  551.       case RXIF_FREE:
  552.          FreeVec( rd );
  553.          break;
  554.    }
  555.    return;
  556. }
  557. ///
  558. /* $ARB: E 17 MAILMOVE */
  559.  
  560. /* $ARB: B 18 MAILREAD */
  561. /// OK
  562. void rx_mailread( struct RexxHost *host, struct rxd_mailread **rxd, long action, struct RexxMsg *rexxmsg )
  563. {
  564.    struct rxd_mailread *rd = *rxd;
  565.    struct Mail *mail;
  566.    int winnr;
  567.  
  568.    switch( action )
  569.    {
  570.       case RXIF_INIT:
  571.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  572.          break;
  573.          
  574.       case RXIF_ACTION:
  575.          winnr = rd->arg.window ? *rd->arg.window : -1;
  576.          rd->res.window = &G->ActiveReadWin;
  577.          if (winnr < 0)
  578.          {
  579.             if (mail = MA_GetActiveMail(ANYBOX, NULL, NULL))
  580.                if ((winnr = RE_Open(-1, TRUE)) >= 0)
  581.                {
  582.                   G->ActiveReadWin = winnr;
  583.                   if (!rd->arg.quiet) set(G->RE[winnr]->GUI.WI, MUIA_Window_Open, TRUE);
  584.                   RE_ReadMessage(winnr, mail);
  585.                }
  586.                else rd->rc = RETURN_ERROR;
  587.             else rd->rc = RETURN_WARN;
  588.          }
  589.          else
  590.          {
  591.             if (winnr >= 0 && winnr <= 3) if (G->RE[winnr]) G->ActiveReadWin = winnr;
  592.             else rd->rc = RETURN_ERROR;
  593.          }
  594.          break;
  595.       
  596.       case RXIF_FREE:
  597.          FreeVec( rd );
  598.          break;
  599.    }
  600.    return;
  601. }
  602. ///
  603. /* $ARB: E 18 MAILREAD */
  604.  
  605. /* $ARB: B 19 MAILSEND */
  606. /// OK
  607. void rx_mailsend( struct RexxHost *host, struct rxd_mailsend **rxd, long action, struct RexxMsg *rexxmsg )
  608. {
  609.    struct rxd_mailsend *rd = *rxd;
  610.    switch( action )
  611.    {
  612.       case RXIF_INIT:
  613.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  614.          break;
  615.          
  616.       case RXIF_ACTION:
  617.          if (!MA_Send(rd->arg.all ? SEND_ALL : SEND_ACTIVE)) rd->rc = RETURN_WARN;
  618.          break;
  619.       
  620.       case RXIF_FREE:
  621.          FreeVec( rd );
  622.          break;
  623.    }
  624.    return;
  625. }
  626. ///
  627. /* $ARB: E 19 MAILSEND */
  628.  
  629. /* $ARB: B 20 MAILDELETE */
  630. /// OK
  631. void rx_maildelete( struct RexxHost *host, struct rxd_maildelete **rxd, long action, struct RexxMsg *rexxmsg )
  632. {
  633.    struct rxd_maildelete *rd = *rxd;
  634.    switch( action )
  635.    {
  636.       case RXIF_INIT:
  637.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  638.          break;
  639.          
  640.       case RXIF_ACTION:
  641.          MA_DeleteMessage(rd->arg.atonce, rd->arg.force);
  642.          break;
  643.       
  644.       case RXIF_FREE:
  645.          FreeVec( rd );
  646.          break;
  647.    }
  648.    return;
  649. }
  650. ///
  651. /* $ARB: E 20 MAILDELETE */
  652.  
  653. /* $ARB: B 21 MAILCHECK */
  654. /// OK
  655. void rx_mailcheck( struct RexxHost *host, struct rxd_mailcheck **rxd, long action, struct RexxMsg *rexxmsg )
  656. {
  657.    struct rxd_mailcheck *rd = *rxd;
  658.    int pop, popnr = -2;
  659.    switch( action )
  660.    {
  661.       case RXIF_INIT:
  662.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  663.          break;
  664.          
  665.       case RXIF_ACTION:
  666.          if (rd->arg.pop) { if ((pop = *rd->arg.pop) >= 0 && pop < MAXP3) if (C->P3[pop]) popnr = pop; }
  667.          else popnr = -1;
  668.          if (popnr > -2)
  669.          {
  670.             if (rd->arg.manual) MA_PopNow(POP_USER, popnr);
  671.             else
  672.             {
  673.                MA_PopNow(POP_REXX, popnr);
  674.                rd->res.downloaded = &G->LastDL.Downloaded;
  675.                rd->res.onserver = &G->LastDL.OnServer;
  676.                rd->res.dupskipped = &G->LastDL.DupSkipped;
  677.                rd->res.deleted = &G->LastDL.Deleted;
  678.                if (G->LastDL.Error) rd->rc = RETURN_WARN;
  679.             }
  680.          }
  681.          else rd->rc = RETURN_ERROR;
  682.          break;
  683.       
  684.       case RXIF_FREE:
  685.          FreeVec( rd );
  686.          break;
  687.    }
  688.    return;
  689. }
  690. ///
  691. /* $ARB: E 21 MAILCHECK */
  692.  
  693. /* $ARB: B 22 MAILIMPORT */
  694. /// OK
  695. void rx_mailimport( struct RexxHost *host, struct rxd_mailimport **rxd, long action, struct RexxMsg *rexxmsg )
  696. {
  697.    struct rxd_mailimport *rd = *rxd;
  698.    switch( action )
  699.    {
  700.       case RXIF_INIT:
  701.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  702.          break;
  703.          
  704.       case RXIF_ACTION:
  705.          if (!MA_ImportMessages(rd->arg.filename)) rd->rc = RETURN_ERROR;
  706.          else if (!rd->arg.wait) TR_ProcessIMPORTFunc();
  707.          break;
  708.       
  709.       case RXIF_FREE:
  710.          FreeVec( rd );
  711.          break;
  712.    }
  713.    return;
  714. }
  715. ///
  716. /* $ARB: E 22 MAILIMPORT */
  717.  
  718. /* $ARB: B 23 MAILEXPORT */
  719. /// OK
  720. void rx_mailexport( struct RexxHost *host, struct rxd_mailexport **rxd, long action, struct RexxMsg *rexxmsg )
  721. {
  722.    struct rxd_mailexport *rd = *rxd;
  723.    switch( action )
  724.    {
  725.       case RXIF_INIT:
  726.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  727.          break;
  728.          
  729.       case RXIF_ACTION:
  730.          if (!MA_ExportMessages(rd->arg.all, rd->arg.filename, rd->arg.append)) rd->rc = RETURN_ERROR;
  731.          break;
  732.       
  733.       case RXIF_FREE:
  734.          FreeVec( rd );
  735.          break;
  736.    }
  737.    return;
  738. }
  739. ///
  740. /* $ARB: E 23 MAILEXPORT */
  741.  
  742. /* $ARB: B 24 MAILUPDATE */
  743. /// OK
  744. void rx_mailupdate( struct RexxHost *host, struct rxd_mailupdate **rxd, long action, struct RexxMsg *rexxmsg )
  745. {
  746.    struct rxd_mailupdate *rd = *rxd;
  747.    switch( action )
  748.    {
  749.       case RXIF_INIT:
  750.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  751.          break;
  752.          
  753.       case RXIF_ACTION:
  754.          DoMethod(G->App, MUIM_CallHook, &MA_RescanIndexHook);
  755.          break;
  756.       
  757.       case RXIF_FREE:
  758.          FreeVec( rd );
  759.          break;
  760.    }
  761.    return;
  762. }
  763. ///
  764. /* $ARB: E 24 MAILUPDATE */
  765.  
  766. /* $ARB: B 25 MAILFILTER */
  767. /// OK
  768. void rx_mailfilter( struct RexxHost *host, struct rxd_mailfilter **rxd, long action, struct RexxMsg *rexxmsg )
  769. {
  770.    struct rxd_mailfilter *rd = *rxd;
  771.    struct RuleResult *rr = &G->RRs;
  772.    switch( action )
  773.    {
  774.       case RXIF_INIT:
  775.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  776.          break;
  777.          
  778.       case RXIF_ACTION:
  779.          DoMethod(G->App, MUIM_CallHook, &MA_ApplyRulesHook, rd->arg.all ? APPLY_RX_ALL : APPLY_RX, 0, FALSE);
  780.          rd->res.checked = &rr->Checked;
  781.          rd->res.bounced = &rr->Bounced;
  782.          rd->res.forwarded = &rr->Forwarded;
  783.          rd->res.replied = &rr->Replied;
  784.          rd->res.executed = &rr->Executed;
  785.          rd->res.moved = &rr->Moved;
  786.          rd->res.deleted = &rr->Deleted;
  787.          break;
  788.       
  789.       case RXIF_FREE:
  790.          FreeVec( rd );
  791.          break;
  792.    }
  793.    return;
  794. }
  795. ///
  796. /* $ARB: E 25 MAILFILTER */
  797.  
  798. /* $ARB: B 27 MAILINFO */
  799. /// OK
  800. void rx_mailinfo( struct RexxHost *host, struct rxd_mailinfo **rxd, long action, struct RexxMsg *rexxmsg )
  801. {
  802.    struct {
  803.       struct rxd_mailinfo rd;
  804.       long active;
  805.       char from[SIZE_ADDRESS], to[SIZE_ADDRESS], replyto[SIZE_ADDRESS], flags[SIZE_SMALL];
  806.       char filename[SIZE_PATHFILE], date[32];
  807.    } *rd = (void *)*rxd;
  808.    struct Mail *mail;
  809.    struct Folder *folder;
  810.    int pf, vf;
  811.  
  812.    switch( action )
  813.    {
  814.       case RXIF_INIT:
  815.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  816.          break;
  817.          
  818.       case RXIF_ACTION:
  819.          if (rd->rd.arg.index)
  820.          {
  821.             rd->active = *rd->rd.arg.index;
  822.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_GetEntry, rd->active, &mail);
  823.          }
  824.          else mail = MA_GetActiveMail(ANYBOX, &folder, (int *)&rd->active);
  825.          if (mail)
  826.          {
  827.             pf = (mail->Flags & 0x0700) >> 8;
  828.             vf = (mail->Flags & 0x3800) >> 11;
  829.             GetMailFile(rd->rd.res.filename = rd->filename, folder, mail);
  830.             rd->rd.res.index = &rd->active;
  831.             rd->rd.res.status = Status[mail->Status];
  832.             stccpy(rd->rd.res.from    = rd->from   , BuildAddrName2(&mail->From), SIZE_ADDRESS);
  833.             stccpy(rd->rd.res.to      = rd->to     , BuildAddrName2(&mail->To), SIZE_ADDRESS);
  834.             stccpy(rd->rd.res.replyto = rd->replyto, BuildAddrName2(GetReturnAddress(mail)), SIZE_ADDRESS);
  835.             strcpy(rd->rd.res.date    = rd->date   , DateStamp2String(&mail->Date, DSS_USDATETIME));
  836.             rd->rd.res.subject = mail->Subject;
  837.             rd->rd.res.size = &mail->Size;
  838.             rd->rd.res.msgid = &mail->cMsgID;
  839.             sprintf(rd->rd.res.flags = rd->flags, "%c%c%c%c%c-%c%c",
  840.                (mail->Flags&MFLAG_MULTIRCPT)?'M':'-', (mail->Flags&MFLAG_MULTIPART)?'A':'-', (mail->Flags&MFLAG_REPORT)?'R':'-',
  841.                (mail->Flags&MFLAG_CRYPT)?'C':'-', (mail->Flags&MFLAG_SIGNED)?'S':'-', pf?pf+'0':'-', vf?vf+'0':'-');
  842.          }
  843.          else rd->rd.rc = RETURN_ERROR;
  844.          break;
  845.       
  846.       case RXIF_FREE:
  847.          FreeVec( rd );
  848.          break;
  849.    }
  850.    return;
  851. }
  852. ///
  853. /* $ARB: E 27 MAILINFO */
  854.  
  855. /* $ARB: B 28 SETFOLDER */
  856. /// OK
  857. void rx_setfolder( struct RexxHost *host, struct rxd_setfolder **rxd, long action, struct RexxMsg *rexxmsg )
  858. {
  859.    struct rxd_setfolder *rd = *rxd;
  860.    struct Folder *folder;
  861.    switch( action )
  862.    {
  863.       case RXIF_INIT:
  864.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  865.          break;
  866.          
  867.       case RXIF_ACTION:
  868.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL)) MA_ChangeFolder(folder);
  869.          else rd->rc = RETURN_ERROR;
  870.          break;
  871.       
  872.       case RXIF_FREE:
  873.          FreeVec( rd );
  874.          break;
  875.    }
  876.    return;
  877. }
  878. ///
  879. /* $ARB: E 28 SETFOLDER */
  880.  
  881. /* $ARB: B 29 SETMAIL */
  882. /// OK
  883. void rx_setmail( struct RexxHost *host, struct rxd_setmail **rxd, long action, struct RexxMsg *rexxmsg )
  884. {
  885.    struct rxd_setmail *rd = *rxd;
  886.    int mail, max;
  887.    switch( action )
  888.    {
  889.       case RXIF_INIT:
  890.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  891.          break;
  892.          
  893.       case RXIF_ACTION:
  894.          mail = *rd->arg.num;
  895.          get(G->MA->GUI.NL_MAILS, MUIA_NList_Entries, &max);
  896.          if (mail < 0 || mail >= max) rd->rc = RETURN_ERROR;
  897.          else set(G->MA->GUI.NL_MAILS, MUIA_NList_Active, mail);
  898.          break;
  899.       
  900.       case RXIF_FREE:
  901.          FreeVec( rd );
  902.          break;
  903.    }
  904.    return;
  905. }
  906. ///
  907. /* $ARB: E 29 SETMAIL */
  908.  
  909. /* $ARB: B 30 WRITEEDITOR */
  910. /// OK
  911. void rx_writeeditor( struct RexxHost *host, struct rxd_writeeditor **rxd, long action, struct RexxMsg *rexxmsg )
  912. {
  913.    struct rxd_writeeditor *rd = *rxd;
  914.    switch( action )
  915.    {
  916.       case RXIF_INIT:
  917.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  918.          break;
  919.          
  920.       case RXIF_ACTION:
  921.          if (G->WR[G->ActiveWriteWin])
  922.          {
  923.             ULONG p = DoMethod(G->WR[G->ActiveWriteWin]->GUI.TE_EDIT, MUIM_TextEditor_ARexxCmd, rd->arg.command);
  924.             switch (p)
  925.             {
  926.                case FALSE: rd->rc = RETURN_WARN; break;
  927.                case TRUE:  break;
  928.                default:    rd->res.result = (char *)p; break;
  929.             }
  930.          }
  931.          else rd->rc = RETURN_ERROR;
  932.          break;
  933.       
  934.       case RXIF_FREE:
  935.          if (rd->res.result) FreeVec(rd->res.result);
  936.          FreeVec( rd );
  937.          break;
  938.    }
  939.    return;
  940. }
  941. ///
  942. /* $ARB: E 30 WRITEEDITOR */
  943.  
  944. /* $ARB: B 31 REQUEST */
  945. /// OK
  946. void rx_request( struct RexxHost *host, struct rxd_request **rxd, long action, struct RexxMsg *rexxmsg )
  947. {
  948.    struct {
  949.       struct rxd_request rd;
  950.       long result;
  951.    } *rd = (void *)*rxd;
  952.    char *reqtext;
  953.  
  954.    switch( action )
  955.    {
  956.       case RXIF_INIT:
  957.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  958.          break;
  959.          
  960.       case RXIF_ACTION:
  961.          reqtext = AllocReqText(rd->rd.arg.body);
  962.          rd->result = MUI_Request(G->App, NULL, 0, NULL, rd->rd.arg.gadgets, reqtext);
  963.          rd->rd.res.result = &rd->result;
  964.          free(reqtext);
  965.          break;
  966.       
  967.       case RXIF_FREE:
  968.          FreeVec( rd );
  969.          break;
  970.    }
  971.    return;
  972. }
  973. ///
  974. /* $ARB: E 31 REQUEST */
  975.  
  976. /* $ARB: B 32 MAILARCHIVE */
  977. /// OK OBSOLETE
  978. void rx_mailarchive( struct RexxHost *host, struct rxd_mailarchive **rxd, long action, struct RexxMsg *rexxmsg )
  979. {
  980.    rx_mailmove(host, (struct rxd_mailmove **)rxd, action, rexxmsg);
  981. }
  982. ///
  983. /* $ARB: E 32 MAILARCHIVE */
  984.  
  985. /* $ARB: B 33 MAILSENDALL */
  986. /// OK OBSOLETE
  987. void rx_mailsendall( struct RexxHost *host, struct rxd_mailsendall **rxd, long action, struct RexxMsg *rexxmsg )
  988. {
  989.    struct rxd_mailsendall *rd = *rxd;
  990.    switch( action )
  991.    {
  992.       case RXIF_INIT:
  993.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  994.          break;
  995.          
  996.       case RXIF_ACTION:
  997.          if (!MA_Send(SEND_ALL)) rd->rc = RETURN_WARN;
  998.          break;
  999.       
  1000.       case RXIF_FREE:
  1001.          FreeVec( rd );
  1002.          break;
  1003.    }
  1004.    return;
  1005. }
  1006. ///
  1007. /* $ARB: E 33 MAILSENDALL */
  1008.  
  1009. /* $ARB: B 35 GETFOLDERINFO */
  1010. /// OK
  1011. void rx_getfolderinfo( struct RexxHost *host, struct rxd_getfolderinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1012. {
  1013.    struct {
  1014.       struct rxd_getfolderinfo rd;
  1015.       char result[SIZE_SMALL];
  1016.    } *rd = (void *)*rxd;
  1017.    struct Folder *fo;
  1018.    int num;
  1019.    char *key;
  1020.  
  1021.    switch( action )
  1022.    {
  1023.       case RXIF_INIT:
  1024.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1025.          break;
  1026.          
  1027.       case RXIF_ACTION:
  1028.          key = rd->rd.arg.item;
  1029.          fo = FO_GetCurrentFolder();
  1030.          get(G->MA->GUI.NL_FOLDERS, MUIA_NList_Active, &num);
  1031.          if (!strnicmp(key, "NUM", 3)) sprintf(rd->rd.res.value = rd->result, "%ld", num);
  1032.          else if (!strnicmp(key, "NAM", 3)) rd->rd.res.value = fo->Name;
  1033.          else if (!strnicmp(key, "PAT", 3)) rd->rd.res.value = fo->Path;
  1034.          else if (!strnicmp(key, "MAX", 3)) sprintf(rd->rd.res.value = rd->result, "%ld", fo->Total);
  1035.          else rd->rd.rc = RETURN_ERROR;
  1036.          break;
  1037.       
  1038.       case RXIF_FREE:
  1039.          FreeVec( rd );
  1040.          break;
  1041.    }
  1042.    return;
  1043. }
  1044. ///
  1045. /* $ARB: E 35 GETFOLDERINFO */
  1046.  
  1047. /* $ARB: B 36 GETMAILINFO */
  1048. /// OK OBSOLETE
  1049. void rx_getmailinfo( struct RexxHost *host, struct rxd_getmailinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1050. {
  1051.    struct {
  1052.       struct rxd_getmailinfo rd;
  1053.       char result[SIZE_LARGE];
  1054.    } *rd = (void *)*rxd;
  1055.    struct Mail *mail;
  1056.    int active;
  1057.    char *key;
  1058.  
  1059.    switch( action )
  1060.    {
  1061.       case RXIF_INIT:
  1062.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1063.          break;
  1064.          
  1065.       case RXIF_ACTION:
  1066.          if (mail = MA_GetActiveMail(ANYBOX, NULL, &active))
  1067.          {
  1068.             rd->rd.res.value = rd->result;
  1069.             key = rd->rd.arg.item;
  1070.             if (!strnicmp(key, "ACT", 3)) sprintf(rd->result, "%d", active);
  1071.             else if (!strnicmp(key, "STA", 3)) rd->rd.res.value = Status[mail->Status];
  1072.             else if (!strnicmp(key, "FRO", 3)) strcpy(rd->result, BuildAddrName2(&mail->From));
  1073.             else if (!strnicmp(key, "TO" , 2)) strcpy(rd->result, BuildAddrName2(&mail->To));
  1074.             else if (!strnicmp(key, "REP", 3)) strcpy(rd->result, BuildAddrName2(GetReturnAddress(mail)));
  1075.             else if (!strnicmp(key, "SUB", 3)) rd->rd.res.value = mail->Subject;
  1076.             else if (!strnicmp(key, "FIL", 3)) GetMailFile(rd->rd.res.value = rd->result, mail->Folder, mail);
  1077.             else rd->rd.rc = RETURN_ERROR;
  1078.          }
  1079.          else rd->rd.rc = RETURN_ERROR;
  1080.          break;
  1081.       
  1082.       case RXIF_FREE:
  1083.          FreeVec( rd );
  1084.          break;
  1085.    }
  1086.    return;
  1087. }
  1088. ///
  1089. /* $ARB: E 36 GETMAILINFO */
  1090.  
  1091. /* $ARB: B 37 GETCONFIGINFO */
  1092. /// OK OBSOLETE
  1093. void rx_getconfiginfo( struct RexxHost *host, struct rxd_getconfiginfo **rxd, long action, struct RexxMsg *rexxmsg )
  1094. {
  1095.    struct rxd_getconfiginfo *rd = *rxd;
  1096.    char *key;
  1097.    switch( action )
  1098.    {
  1099.       case RXIF_INIT:
  1100.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1101.          break;
  1102.          
  1103.       case RXIF_ACTION:
  1104.          key = rd->arg.item;
  1105.          if (!strnicmp(key, "NAM", 3)) rd->res.value = C->RealName;
  1106.          else if (!strnicmp(key, "EMA", 3)) rd->res.value = C->EmailAddress;
  1107.          else rd->rc = RETURN_ERROR;
  1108.          break;
  1109.       
  1110.       case RXIF_FREE:
  1111.          FreeVec( rd );
  1112.          break;
  1113.    }
  1114.    return;
  1115. }
  1116. ///
  1117. /* $ARB: E 37 GETCONFIGINFO */
  1118.  
  1119. /* $ARB: B 38 FOLDERINFO */
  1120. /// OK
  1121. void rx_folderinfo( struct RexxHost *host, struct rxd_folderinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1122. {
  1123.    struct rxd_folderinfo *rd = *rxd;
  1124.    struct Folder *fo;
  1125.    static long num;
  1126.    switch( action )
  1127.    {
  1128.       case RXIF_INIT:
  1129.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1130.          break;
  1131.          
  1132.       case RXIF_ACTION:
  1133.          fo = rd->arg.folder ? FO_GetFolderRexx(rd->arg.folder, NULL) : FO_GetCurrentFolder();
  1134.          if (fo)
  1135.          {
  1136.             num = FO_GetFolderPosition(fo);
  1137.             rd->res.number = #
  1138.             rd->res.name = fo->Name;
  1139.             rd->res.path = fo->Path;
  1140.             rd->res.total = (long *)&fo->Total;
  1141.             rd->res.new = (long *)&fo->New;
  1142.             rd->res.unread = (long *)&fo->Unread;
  1143.             rd->res.size = (long *)&fo->Size;
  1144.          }
  1145.          else rd->rc = RETURN_ERROR;
  1146.          break;
  1147.       
  1148.       case RXIF_FREE:
  1149.          FreeVec( rd );
  1150.          break;
  1151.    }
  1152.    return;
  1153. }
  1154. ///
  1155. /* $ARB: E 38 FOLDERINFO */
  1156.  
  1157. /* $ARB: B 40 WRITESUBJECT */
  1158. /// OK
  1159. void rx_writesubject( struct RexxHost *host, struct rxd_writesubject **rxd, long action, struct RexxMsg *rexxmsg )
  1160. {
  1161.    struct rxd_writesubject *rd = *rxd;
  1162.    switch( action )
  1163.    {
  1164.       case RXIF_INIT:
  1165.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1166.          break;
  1167.          
  1168.       case RXIF_ACTION:
  1169.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_SUBJECT, rd->arg.subject);
  1170.          break;
  1171.       
  1172.       case RXIF_FREE:
  1173.          FreeVec( rd );
  1174.          break;
  1175.    }
  1176.    return;
  1177. }
  1178. ///
  1179. /* $ARB: E 40 WRITESUBJECT */
  1180.  
  1181. /* $ARB: B 41 SCREENTOBACK */
  1182. /// OK
  1183. void rx_screentoback( struct RexxHost *host, struct rxd_screentoback **rxd, long action, struct RexxMsg *rexxmsg )
  1184. {
  1185.    struct rxd_screentoback *rd = *rxd;
  1186.    switch( action )
  1187.    {
  1188.       case RXIF_INIT:
  1189.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1190.          break;
  1191.          
  1192.       case RXIF_ACTION:
  1193.          rd->rc = 0;
  1194.          if (G->MA) DoMethod(G->MA->GUI.WI, MUIM_Window_ScreenToBack);
  1195.          else rd->rc = RETURN_WARN;
  1196.          break;
  1197.       
  1198.       case RXIF_FREE:
  1199.          FreeVec( rd );
  1200.          break;
  1201.    }
  1202.    return;
  1203. }
  1204. ///
  1205. /* $ARB: E 41 SCREENTOBACK */
  1206.  
  1207. /* $ARB: B 42 SCREENTOFRONT */
  1208. /// OK
  1209. void rx_screentofront( struct RexxHost *host, struct rxd_screentofront **rxd, long action, struct RexxMsg *rexxmsg )
  1210. {
  1211.    struct rxd_screentofront *rd = *rxd;
  1212.    switch( action )
  1213.    {
  1214.       case RXIF_INIT:
  1215.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1216.          break;
  1217.          
  1218.       case RXIF_ACTION:
  1219.          rd->rc = 0;
  1220.          if (G->MA) DoMethod(G->MA->GUI.WI, MUIM_Window_ScreenToFront);
  1221.          else rd->rc = RETURN_WARN;
  1222.          break;
  1223.       
  1224.       case RXIF_FREE:
  1225.          FreeVec( rd );
  1226.          break;
  1227.    }
  1228.    return;
  1229. }
  1230. ///
  1231. /* $ARB: E 42 SCREENTOFRONT */
  1232.  
  1233. /* $ARB: B 46 SETFLAG */
  1234. /// OK
  1235. void rx_setflag( struct RexxHost *host, struct rxd_setflag **rxd, long action, struct RexxMsg *rexxmsg )
  1236. {
  1237.    struct rxd_setflag *rd = *rxd;
  1238.    int flag;
  1239.    struct Mail *mail;
  1240.    switch( action )
  1241.    {
  1242.       case RXIF_INIT:
  1243.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1244.          break;
  1245.          
  1246.       case RXIF_ACTION:
  1247.          if (mail = MA_GetActiveMail(ANYBOX, NULL, NULL))
  1248.          {
  1249.             if (rd->arg.vol) { if ((flag = *rd->arg.vol) >= 0 && flag < 8)
  1250.                mail->Flags = (mail->Flags&0xC7FF) | (flag<<11);
  1251.                
  1252.             else rd->rc = RETURN_ERROR;
  1253.             }
  1254.             if (rd->arg.per) if ((flag = *rd->arg.per) >= 0 && flag < 8)
  1255.             {
  1256.                if (flag != ((mail->Flags&0x0700)>>8))
  1257.                {
  1258.                   mail->Flags = (mail->Flags&0xF8FF) | (flag<<8);
  1259.                   MA_SetMailStatus(mail, mail->Status|0x100);
  1260.                }
  1261.             }
  1262.             else rd->rc = RETURN_ERROR;
  1263.          }
  1264.          else rd->rc = RETURN_WARN;
  1265.          break;
  1266.       
  1267.       case RXIF_FREE:
  1268.          FreeVec( rd );
  1269.          break;
  1270.    }
  1271.    return;
  1272. }
  1273. ///
  1274. /* $ARB: E 46 SETFLAG */
  1275.  
  1276. /* $ARB: B 47 MAILEDIT */
  1277. /// OK
  1278. void rx_mailedit( struct RexxHost *host, struct rxd_mailedit **rxd, long action, struct RexxMsg *rexxmsg )
  1279. {
  1280.    struct rxd_mailedit *rd = *rxd;
  1281.    int winnr;
  1282.    switch( action )
  1283.    {
  1284.       case RXIF_INIT:
  1285.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1286.          break;
  1287.          
  1288.       case RXIF_ACTION:
  1289.          rd->res.window = &G->ActiveWriteWin;
  1290.          if ((winnr = MA_NewMessage(NEW_EDIT, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  1291.          else rd->rc = RETURN_ERROR;
  1292.          break;
  1293.       
  1294.       case RXIF_FREE:
  1295.          FreeVec( rd );
  1296.          break;
  1297.    }
  1298.    return;
  1299. }
  1300. ///
  1301. /* $ARB: E 47 MAILEDIT */
  1302.  
  1303. /* $ARB: B 48 READINFO */
  1304. /// OK
  1305. void rx_readinfo( struct RexxHost *host, struct rxd_readinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1306. {
  1307.    struct rxd_readinfo *rd = *rxd;
  1308.    struct Part *part;
  1309.    int i, parts;
  1310.    switch( action )
  1311.    {
  1312.       case RXIF_INIT:
  1313.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1314.          break;
  1315.          
  1316.       case RXIF_ACTION:
  1317.          if (G->RE[G->ActiveReadWin])
  1318.          {
  1319.             for (parts = 0, part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; parts++, part = part->Next);
  1320.             rd->res.filename = calloc(parts+1, sizeof(char *));
  1321.             rd->res.filetype = calloc(parts+1, sizeof(char *));
  1322.             rd->res.filesize = calloc(parts+1, sizeof(long));
  1323.             rd->res.tempfile = calloc(parts+1, sizeof(char *));
  1324.             for (i = 0, part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; i++, part = part->Next)
  1325.             {
  1326.                rd->res.filename[i] = part->Name;
  1327.                rd->res.filetype[i] = part->ContentType;
  1328.                rd->res.filesize[i] = (long *)&part->Size;
  1329.                rd->res.tempfile[i] = part->Filename;
  1330.             }
  1331.          }
  1332.          else rd->rc = RETURN_ERROR;
  1333.          break;
  1334.       
  1335.       case RXIF_FREE:
  1336.          if (rd->res.filename) free(rd->res.filename);
  1337.          if (rd->res.filetype) free(rd->res.filetype);
  1338.          if (rd->res.filesize) free(rd->res.filesize);
  1339.          if (rd->res.tempfile) free(rd->res.tempfile);
  1340.          FreeVec( rd );
  1341.          break;
  1342.    }
  1343.    return;
  1344. }
  1345. ///
  1346. /* $ARB: E 48 READINFO */
  1347.  
  1348. /* $ARB: B 49 READSAVE */
  1349. /// OK
  1350. void rx_readsave( struct RexxHost *host, struct rxd_readsave **rxd, long action, struct RexxMsg *rexxmsg )
  1351. {
  1352.    struct rxd_readsave *rd = *rxd;
  1353.    struct Part *part;
  1354.    struct TempFile *tf;
  1355.    BOOL success = FALSE;
  1356.    char file[SIZE_PATHFILE];
  1357.    switch( action )
  1358.    {
  1359.       case RXIF_INIT:
  1360.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1361.          break;
  1362.          
  1363.       case RXIF_ACTION:
  1364.          if (G->RE[G->ActiveReadWin])
  1365.             if (rd->arg.part)
  1366.             {
  1367.                for (part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; part = part->Next)
  1368.                   if (part->Nr == *(rd->arg.part))
  1369.                      if (RE_DecodePart(part))
  1370.                      {
  1371.                         strmfp(file, C->DetachDir, part->Name);
  1372.                         success = RE_Export(G->ActiveReadWin, part->Filename, rd->arg.filename ? rd->arg.filename : "", part->Name, part->Nr, TRUE, rd->arg.overwrite, part->ContentType);
  1373.                      }
  1374.             }
  1375.             else if (tf = OpenTempFile("w"))
  1376.             {
  1377.                RE_SaveDisplay(G->ActiveReadWin, tf->FP);
  1378.                fclose(tf->FP); tf->FP = NULL;
  1379.                success = RE_Export(G->ActiveReadWin, tf->Filename, rd->arg.filename ? rd->arg.filename : "", "", 0, TRUE, rd->arg.overwrite, ContType[CT_TX_PLAIN]);
  1380.                CloseTempFile(tf);
  1381.             }
  1382.          if (!success) rd->rc = RETURN_ERROR;
  1383.          break;
  1384.       
  1385.       case RXIF_FREE:
  1386.          FreeVec( rd );
  1387.          break;
  1388.    }
  1389.    return;
  1390. }
  1391. ///
  1392. /* $ARB: E 49 READSAVE */
  1393.  
  1394. /* $ARB: B 50 READPRINT */
  1395. /// OK
  1396. void rx_readprint( struct RexxHost *host, struct rxd_readprint **rxd, long action, struct RexxMsg *rexxmsg )
  1397. {
  1398.    struct rxd_readprint *rd = *rxd;
  1399.    struct Part *part;
  1400.    FILE *prt;
  1401.    BOOL success = FALSE;
  1402.    switch( action )
  1403.    {
  1404.       case RXIF_INIT:
  1405.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1406.          break;
  1407.          
  1408.       case RXIF_ACTION:
  1409.          if (C->PrinterCheck) if (!CheckPrinter()) { rd->rc = RETURN_ERROR; break; }
  1410.          if (G->RE[G->ActiveReadWin])
  1411.             if (rd->arg.part)
  1412.             {
  1413.                for (part = G->RE[G->ActiveReadWin]->FirstPart->Next; part; part = part->Next)
  1414.                   if (part->Nr == *(rd->arg.part))
  1415.                      if (RE_DecodePart(part)) success = CopyFile("PRT:", 0, part->Filename, 0);
  1416.             }
  1417.             else if (prt = fopen("PRT:","w"))
  1418.             {
  1419.                RE_SaveDisplay(G->ActiveReadWin, prt);
  1420.                fclose(prt);
  1421.                success = TRUE;
  1422.             }
  1423.          if (!success) rd->rc = RETURN_ERROR;
  1424.          break;
  1425.       
  1426.       case RXIF_FREE:
  1427.          FreeVec( rd );
  1428.          break;
  1429.    }
  1430.    return;
  1431. }
  1432. ///
  1433. /* $ARB: E 50 READPRINT */
  1434.  
  1435. /* $ARB: B 51 MAILBOUNCE */
  1436. /// OK
  1437. void rx_mailbounce( struct RexxHost *host, struct rxd_mailbounce **rxd, long action, struct RexxMsg *rexxmsg )
  1438. {
  1439.    struct rxd_mailbounce *rd = *rxd;
  1440.    int winnr;
  1441.    switch( action )
  1442.    {
  1443.       case RXIF_INIT:
  1444.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1445.          break;
  1446.          
  1447.       case RXIF_ACTION:
  1448.          rd->res.window = &G->ActiveWriteWin;
  1449.          if ((winnr = MA_NewMessage(NEW_BOUNCE, rd->arg.quiet?NEWF_QUIET:0)) >= 0) G->ActiveWriteWin = winnr;
  1450.          else rd->rc = RETURN_ERROR;
  1451.          break;
  1452.       
  1453.       case RXIF_FREE:
  1454.          FreeVec( rd );
  1455.          break;
  1456.    }
  1457.    return;
  1458. }
  1459. ///
  1460. /* $ARB: E 51 MAILBOUNCE */
  1461.  
  1462. /* $ARB: B 52 ADDRFIND */
  1463. /// OK
  1464. void rx_addrfind( struct RexxHost *host, struct rxd_addrfind **rxd, long action, struct RexxMsg *rexxmsg )
  1465. {
  1466.    struct rxd_addrfind *rd = *rxd;
  1467.    int mode;
  1468.    switch( action )
  1469.    {
  1470.       case RXIF_INIT:
  1471.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1472.          break;
  1473.          
  1474.       case RXIF_ACTION:
  1475.          G->AB->Hits = 0;
  1476.          if (rd->arg.nameonly) mode = rd->arg.emailonly ? ABF_RX_NAMEEMAIL : ABF_RX_NAME;
  1477.                           else mode = rd->arg.emailonly ? ABF_RX_EMAIL     : ABF_RX;
  1478.          AB_FindEntry(MUIV_Lt_GetEntry_ListNode_Root, rd->arg.pattern, mode, NULL);
  1479.          if (G->AB->Hits)
  1480.          {
  1481.             rd->res.alias = calloc(G->AB->Hits+1, sizeof(char *));
  1482.             AB_FindEntry(MUIV_Lt_GetEntry_ListNode_Root, rd->arg.pattern, mode, rd->res.alias);
  1483.          }
  1484.          else rd->rc = RETURN_WARN;
  1485.          break;
  1486.       
  1487.       case RXIF_FREE:
  1488.          if (rd->res.alias) free(rd->res.alias);
  1489.          FreeVec( rd );
  1490.          break;
  1491.    }
  1492.    return;
  1493. }
  1494. ///
  1495. /* $ARB: E 52 ADDRFIND */
  1496.  
  1497. /* $ARB: B 53 ADDRINFO */
  1498. /// OK
  1499. void rx_addrinfo( struct RexxHost *host, struct rxd_addrinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1500. {
  1501.    struct {
  1502.       struct rxd_addrinfo rd;
  1503.       char *members, **memberptr;
  1504.    } *rd = (void *)*rxd;
  1505.    static char *types[3] = { "P","L","G"};
  1506.    char *ptr;
  1507.    struct MUIS_Listtree_TreeNode *tn;
  1508.    int i, hits;
  1509.    switch( action )
  1510.    {
  1511.       case RXIF_INIT:
  1512.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1513.          break;
  1514.          
  1515.       case RXIF_ACTION:
  1516.          hits = 0;
  1517.          if (AB_SearchEntry(MUIV_Lt_GetEntry_ListNode_Root, rd->rd.arg.alias, ASM_ALIAS|ASM_USER|ASM_LIST|ASM_GROUP, &hits, &tn))
  1518.          {
  1519.             struct ABEntry *ab = (struct ABEntry *)tn->tn_User;
  1520.             rd->rd.res.type = types[ab->Type];
  1521.             rd->rd.res.name = ab->RealName;
  1522.             rd->rd.res.email = ab->Address;
  1523.             rd->rd.res.pgp = ab->PGPId;
  1524.             rd->rd.res.homepage = ab->Homepage;
  1525.             rd->rd.res.street = ab->Street;
  1526.             rd->rd.res.city = ab->City;
  1527.             rd->rd.res.country = ab->Country;
  1528.             rd->rd.res.phone = ab->Phone;
  1529.             rd->rd.res.comment = ab->Comment;
  1530.             rd->rd.res.birthdate = &ab->BirthDay;
  1531.             rd->rd.res.image = ab->Photo;
  1532.             if (ab->Members)
  1533.             {
  1534.                rd->members = calloc(strlen(ab->Members)+1,1);
  1535.                strcpy(rd->members, ab->Members);
  1536.                for (hits = 0, ptr = rd->members; *ptr; hits++, ptr++)
  1537.                {
  1538.                   if (ptr = strchr(ptr, '\n')) *ptr = 0; else break;
  1539.                }
  1540.                rd->rd.res.members = rd->memberptr = calloc(hits+1, sizeof(char *));
  1541.                for (i = 0, ptr = rd->members; i < hits; ptr += strlen(ptr)+1) rd->memberptr[i++] = ptr;
  1542.             }
  1543.          }
  1544.          else rd->rd.rc = RETURN_ERROR;
  1545.          break;
  1546.       
  1547.       case RXIF_FREE:
  1548.          if (rd->members) free(rd->members);
  1549.          if (rd->memberptr) free(rd->memberptr);
  1550.          FreeVec( rd );
  1551.          break;
  1552.    }
  1553.    return;
  1554. }
  1555. ///
  1556. /* $ARB: E 53 ADDRINFO */
  1557.  
  1558. /* $ARB: B 54 ADDRRESOLVE */
  1559. /// OK
  1560. void rx_addrresolve( struct RexxHost *host, struct rxd_addrresolve **rxd, long action, struct RexxMsg *rexxmsg )
  1561. {
  1562.    struct {
  1563.       struct rxd_addrresolve rd;
  1564.       char *string;
  1565.    } *rd = (void *)*rxd;
  1566.  
  1567.    switch( action )
  1568.    {
  1569.       case RXIF_INIT:
  1570.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1571.          break;
  1572.          
  1573.       case RXIF_ACTION:
  1574.          rd->rd.res.recpt = rd->string = AllocStrBuf(80);
  1575.          if (WR_ResolveName(-1, rd->rd.arg.alias, &(rd->string), FALSE)) rd->rd.rc = RETURN_WARN;
  1576.          break;
  1577.       
  1578.       case RXIF_FREE:
  1579.          FreeStrBuf(rd->string);
  1580.          FreeVec( rd );
  1581.          break;
  1582.    }
  1583.    return;
  1584. }
  1585. ///
  1586. /* $ARB: E 54 ADDRRESOLVE */
  1587.  
  1588. /* $ARB: B 56 NEWMAILFILE */
  1589. /// OK
  1590. void rx_newmailfile( struct RexxHost *host, struct rxd_newmailfile **rxd, long action, struct RexxMsg *rexxmsg )
  1591. {
  1592.    struct {
  1593.       struct rxd_newmailfile rd;
  1594.       char result[SIZE_PATHFILE];
  1595.    } *rd = (void *)*rxd;
  1596.    struct Folder *folder;
  1597.    switch( action )
  1598.    {
  1599.       case RXIF_INIT:
  1600.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1601.          break;
  1602.          
  1603.       case RXIF_ACTION:
  1604.          if (rd->rd.arg.folder) folder = FO_GetFolderRexx(rd->rd.arg.folder, NULL);
  1605.          else folder = FO_GetCurrentFolder();
  1606.          if (folder) strcpy(rd->rd.res.filename = rd->result, MA_NewMailFile(folder, NULL, 0));
  1607.          else rd->rd.rc = RETURN_ERROR;
  1608.          break;
  1609.       
  1610.       case RXIF_FREE:
  1611.          FreeVec( rd );
  1612.          break;
  1613.    }
  1614.    return;
  1615. }
  1616. ///
  1617. /* $ARB: E 56 NEWMAILFILE */
  1618.  
  1619. /* $ARB: B 57 WRITEFROM */
  1620. /// OK
  1621. void rx_writefrom( struct RexxHost *host, struct rxd_writefrom **rxd, long action, struct RexxMsg *rexxmsg )
  1622. {
  1623.    struct rxd_writefrom *rd = *rxd;
  1624.    switch( action )
  1625.    {
  1626.       case RXIF_INIT:
  1627.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1628.          break;
  1629.          
  1630.       case RXIF_ACTION:
  1631.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_FROM, rd->arg.address);
  1632.          else rd->rc = RETURN_ERROR;
  1633.          break;
  1634.       
  1635.       case RXIF_FREE:
  1636.          FreeVec( rd );
  1637.          break;
  1638.    }
  1639.    return;
  1640. }
  1641. ///
  1642. /* $ARB: E 57 WRITEFROM */
  1643.  
  1644. /* $ARB: B 58 WRITEREPLYTO */
  1645. /// OK
  1646. void rx_writereplyto( struct RexxHost *host, struct rxd_writereplyto **rxd, long action, struct RexxMsg *rexxmsg )
  1647. {
  1648.    struct rxd_writereplyto *rd = *rxd;
  1649.    switch( action )
  1650.    {
  1651.       case RXIF_INIT:
  1652.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1653.          break;
  1654.          
  1655.       case RXIF_ACTION:
  1656.          if (G->WR[G->ActiveWriteWin]) setstring(G->WR[G->ActiveWriteWin]->GUI.ST_REPLYTO, rd->arg.address);
  1657.          else rd->rc = RETURN_ERROR;
  1658.          break;
  1659.       
  1660.       case RXIF_FREE:
  1661.          FreeVec( rd );
  1662.          break;
  1663.    }
  1664.    return;
  1665. }
  1666. ///
  1667. /* $ARB: E 58 WRITEREPLYTO */
  1668.  
  1669. /* $ARB: B 59 LISTSELECT */
  1670. /// OK
  1671. void rx_listselect( struct RexxHost *host, struct rxd_listselect **rxd, long action, struct RexxMsg *rexxmsg )
  1672. {
  1673.    struct rxd_listselect *rd = *rxd;
  1674.    APTR nl;
  1675.    switch( action )
  1676.    {
  1677.       case RXIF_INIT:
  1678.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1679.          break;
  1680.          
  1681.       case RXIF_ACTION:
  1682.          nl = G->MA->GUI.NL_MAILS;
  1683.          switch (rd->arg.mode[0])
  1684.          {
  1685.             case 'a': case 'A': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_On, NULL); break;
  1686.             case 'n': case 'N': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_Off, NULL); break;
  1687.             case 't': case 'T': DoMethod(nl, MUIM_NList_Select, MUIV_NList_Select_All, MUIV_NList_Select_Toggle, NULL); break;
  1688.             case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7':
  1689.             case '8': case '9': DoMethod(nl, MUIM_NList_Select, atol(rd->arg.mode), MUIV_NList_Select_On, NULL); break;
  1690.          }
  1691.          break;
  1692.       
  1693.       case RXIF_FREE:
  1694.          FreeVec( rd );
  1695.          break;
  1696.    }
  1697.    return;
  1698. }
  1699. ///
  1700. /* $ARB: E 59 LISTSELECT */
  1701.  
  1702. /* $ARB: B 60 READCLOSE */
  1703. /// OK
  1704. void rx_readclose( struct RexxHost *host, struct rxd_readclose **rxd, long action, struct RexxMsg *rexxmsg )
  1705. {
  1706.    struct rxd_readclose *rd = *rxd;
  1707.    switch( action )
  1708.    {
  1709.       case RXIF_INIT:
  1710.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1711.          break;
  1712.          
  1713.       case RXIF_ACTION:
  1714.          if (G->RE[G->ActiveReadWin]) DoMethod(G->App, MUIM_CallHook, &RE_CloseHook, G->ActiveReadWin);
  1715.          break;
  1716.       
  1717.       case RXIF_FREE:
  1718.          FreeVec( rd );
  1719.          break;
  1720.    }
  1721.    return;
  1722. }
  1723. ///
  1724. /* $ARB: E 60 READCLOSE */
  1725.  
  1726. /* $ARB: B 61 SETMAILFILE */
  1727. /// OK
  1728. void rx_setmailfile( struct RexxHost *host, struct rxd_setmailfile **rxd, long action, struct RexxMsg *rexxmsg )
  1729. {
  1730.    struct rxd_setmailfile *rd = *rxd;
  1731.    struct Mail *mail = NULL;
  1732.    int i;
  1733.    char *mfile;
  1734.  
  1735.    switch( action )
  1736.    {
  1737.       case RXIF_INIT:
  1738.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1739.          break;
  1740.          
  1741.       case RXIF_ACTION:
  1742.          mfile = FilePart(rd->arg.mailfile);
  1743.          for (i = 0;; i++)
  1744.          {
  1745.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_GetEntry, i, &mail);
  1746.             if (!mail) break;
  1747.             if (!stricmp(mail->MailFile, mfile)) { set(G->MA->GUI.NL_MAILS, MUIA_NList_Active, i); break; }
  1748.          }
  1749.          if (!mail) rd->rc = RETURN_WARN;
  1750.          break;
  1751.       
  1752.       case RXIF_FREE:
  1753.          FreeVec( rd );
  1754.          break;
  1755.    }
  1756.    return;
  1757. }
  1758. ///
  1759. /* $ARB: E 61 SETMAILFILE */
  1760.  
  1761. /* $ARB: B 62 MAILCOPY */
  1762. /// OK
  1763. void rx_mailcopy( struct RexxHost *host, struct rxd_mailcopy **rxd, long action, struct RexxMsg *rexxmsg )
  1764. {
  1765.    struct rxd_mailcopy *rd = *rxd;
  1766.    struct Folder *folder;
  1767.    switch( action )
  1768.    {
  1769.       case RXIF_INIT:
  1770.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1771.          break;
  1772.          
  1773.       case RXIF_ACTION:
  1774.          if (folder = FO_GetFolderRexx(rd->arg.folder, NULL))
  1775.             MA_MoveCopy(NULL, FO_GetCurrentFolder(), folder, TRUE);
  1776.          else rd->rc = RETURN_ERROR;
  1777.          break;
  1778.       
  1779.       case RXIF_FREE:
  1780.          FreeVec( rd );
  1781.          break;
  1782.    }
  1783.    return;
  1784. }
  1785. ///
  1786. /* $ARB: E 62 MAILCOPY */
  1787.  
  1788. /* $ARB: B 63 APPBUSY */
  1789. /// OK
  1790. void rx_appbusy( struct RexxHost *host, struct rxd_appbusy **rxd, long action, struct RexxMsg *rexxmsg )
  1791. {
  1792.    struct rxd_appbusy *rd = *rxd;
  1793.    char *s;
  1794.    switch( action )
  1795.    {
  1796.       case RXIF_INIT:
  1797.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1798.          break;
  1799.          
  1800.       case RXIF_ACTION:
  1801.          s = rd->arg.text;
  1802.          if (s) Busy(s, "", 0, 0);
  1803.          rd->rc = BusyLevel ? 1 : 0;
  1804.          break;
  1805.       
  1806.       case RXIF_FREE:
  1807.          FreeVec( rd );
  1808.          break;
  1809.    }
  1810.    return;
  1811. }
  1812. ///
  1813. /* $ARB: E 63 APPBUSY */
  1814.  
  1815. /* $ARB: B 64 APPNOBUSY */
  1816. /// OK
  1817. void rx_appnobusy( struct RexxHost *host, struct rxd_appnobusy **rxd, long action, struct RexxMsg *rexxmsg )
  1818. {
  1819.    struct rxd_appnobusy *rd = *rxd;
  1820.    switch( action )
  1821.    {
  1822.       case RXIF_INIT:
  1823.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1824.          break;
  1825.          
  1826.       case RXIF_ACTION:
  1827.          BusyEnd;
  1828.          rd->rc = BusyLevel ? 1 : 0;
  1829.          break;
  1830.       
  1831.       case RXIF_FREE:
  1832.          FreeVec( rd );
  1833.          break;
  1834.    }
  1835.    return;
  1836. }
  1837. ///
  1838. /* $ARB: E 64 APPNOBUSY */
  1839.  
  1840. /* $ARB: B 65 WRITEMAILTO */
  1841. /// OK OBSOLETE
  1842. void rx_writemailto( struct RexxHost *host, struct rxd_writemailto **rxd, long action, struct RexxMsg *rexxmsg )
  1843. {
  1844.    struct rxd_writemailto *rd = *rxd;
  1845.    switch( action )
  1846.    {
  1847.       case RXIF_INIT:
  1848.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1849.          break;
  1850.          
  1851.       case RXIF_ACTION:
  1852.          if (G->WR[G->ActiveWriteWin]) InsertAddresses(G->WR[G->ActiveWriteWin]->GUI.ST_TO, rd->arg.address, FALSE);
  1853.          else rd->rc = RETURN_ERROR;
  1854.          break;
  1855.       
  1856.       case RXIF_FREE:
  1857.          FreeVec( rd );
  1858.          break;
  1859.    }
  1860.    return;
  1861. }
  1862. ///
  1863. /* $ARB: E 65 WRITEMAILTO */
  1864.  
  1865. /* $ARB: B 66 USERINFO */
  1866. /// OK
  1867. void rx_userinfo( struct RexxHost *host, struct rxd_userinfo **rxd, long action, struct RexxMsg *rexxmsg )
  1868. {
  1869.    struct {
  1870.       struct rxd_userinfo rd;
  1871.       int folders;
  1872.    } *rd = (void *)*rxd;
  1873.    struct User *u = NULL;
  1874.    switch( action )
  1875.    {
  1876.       case RXIF_INIT:
  1877.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1878.          break;
  1879.          
  1880.       case RXIF_ACTION:
  1881.          u = US_GetCurrentUser();
  1882.          rd->rd.res.username = u->Name;
  1883.          rd->rd.res.email = C->EmailAddress;
  1884.          rd->rd.res.realname = C->RealName;
  1885.          rd->rd.res.config = G->CO_PrefsFile;
  1886.          rd->rd.res.maildir = G->MA_MailDir;
  1887.          get(G->MA->GUI.NL_FOLDERS, MUIA_NList_Entries, &rd->folders);
  1888.          rd->rd.res.folders = (long *)&rd->folders;
  1889.          break;
  1890.       
  1891.       case RXIF_FREE:
  1892.          FreeVec( rd );
  1893.          break;
  1894.    }
  1895.    return;
  1896. }
  1897. ///
  1898. /* $ARB: E 66 USERINFO */
  1899.  
  1900. /* $ARB: B 67 MAILSTATUS */
  1901. /// OK
  1902. void rx_mailstatus( struct RexxHost *host, struct rxd_mailstatus **rxd, long action, struct RexxMsg *rexxmsg )
  1903. {
  1904.    struct rxd_mailstatus *rd = *rxd;
  1905.    switch( action )
  1906.    {
  1907.       case RXIF_INIT:
  1908.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1909.          break;
  1910.          
  1911.       case RXIF_ACTION:
  1912.          switch (tolower(rd->arg.status[0]))
  1913.          {
  1914.             case 'o': MA_SetStatusTo(STATUS_OLD); break;
  1915.             case 'u': MA_SetStatusTo(STATUS_UNR); break;
  1916.             case 'h': MA_SetStatusTo(STATUS_HLD); break;
  1917.             case 'w': MA_SetStatusTo(STATUS_WFS); break;
  1918.             default: rd->rc = RETURN_WARN;
  1919.          }
  1920.          break;
  1921.       
  1922.       case RXIF_FREE:
  1923.          FreeVec( rd );
  1924.          break;
  1925.    }
  1926.    return;
  1927. }
  1928. ///
  1929. /* $ARB: E 67 MAILSTATUS */
  1930.  
  1931. /* $ARB: B 68 ISONLINE */
  1932. /// OK
  1933. void rx_isonline( struct RexxHost *host, struct rxd_isonline **rxd, long action, struct RexxMsg *rexxmsg )
  1934. {
  1935.    struct rxd_isonline *rd = *rxd;
  1936.    switch( action )
  1937.    {
  1938.       case RXIF_INIT:
  1939.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1940.          break;
  1941.          
  1942.       case RXIF_ACTION:
  1943.          rd->rc = SocketBase ? 1 : 0;
  1944.          break;
  1945.       
  1946.       case RXIF_FREE:
  1947.          FreeVec( rd );
  1948.          break;
  1949.    }
  1950.    return;
  1951. }
  1952. ///
  1953. /* $ARB: E 68 ISONLINE */
  1954.  
  1955. /* $ARB: B 70 REQUESTSTRING */
  1956. /// OK
  1957. void rx_requeststring( struct RexxHost *host, struct rxd_requeststring **rxd, long action, struct RexxMsg *rexxmsg )
  1958. {
  1959.    struct {
  1960.       struct rxd_requeststring rd;
  1961.       char string[SIZE_DEFAULT];
  1962.    } *rd = (void *)*rxd;
  1963.    char *reqtext;
  1964.  
  1965.    switch( action )
  1966.    {
  1967.       case RXIF_INIT:
  1968.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  1969.          break;
  1970.          
  1971.       case RXIF_ACTION:
  1972.          reqtext = AllocReqText(rd->rd.arg.body);
  1973.          if (rd->rd.arg.string) stccpy(rd->string, rd->rd.arg.string, SIZE_DEFAULT);
  1974.          rd->rd.rc = !StringRequest(rd->string, SIZE_DEFAULT, NULL, reqtext, GetStr(MSG_Okay), NULL, GetStr(MSG_Cancel), rd->rd.arg.secret, G->MA->GUI.WI);
  1975.          rd->rd.res.string = rd->string;
  1976.          free(reqtext);
  1977.          break;
  1978.       
  1979.       case RXIF_FREE:
  1980.          FreeVec( rd );
  1981.          break;
  1982.    }
  1983.    return;
  1984. }
  1985. ///
  1986. /* $ARB: E 70 REQUESTSTRING */
  1987.  
  1988. /* $ARB: B 71 REQUESTFOLDER */
  1989. /// OK
  1990. void rx_requestfolder( struct RexxHost *host, struct rxd_requestfolder **rxd, long action, struct RexxMsg *rexxmsg )
  1991. {
  1992.    struct rxd_requestfolder *rd = *rxd;
  1993.    char *reqtext;
  1994.    struct Folder *exfolder, *folder;
  1995.  
  1996.    switch( action )
  1997.    {
  1998.       case RXIF_INIT:
  1999.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2000.          break;
  2001.          
  2002.       case RXIF_ACTION:
  2003.          reqtext = AllocReqText(rd->arg.body);
  2004.          exfolder = rd->arg.excludeactive ? FO_GetCurrentFolder() : NULL;
  2005.          if (folder = FolderRequest(NULL, reqtext, GetStr(MSG_Okay), GetStr(MSG_Cancel), exfolder, G->MA->GUI.WI)) rd->res.folder = folder->Name;
  2006.          else rd->rc = 1;
  2007.          free(reqtext);
  2008.          break;
  2009.       
  2010.       case RXIF_FREE:
  2011.          FreeVec( rd );
  2012.          break;
  2013.    }
  2014.    return;
  2015. }
  2016. ///
  2017. /* $ARB: E 71 REQUESTFOLDER */
  2018.  
  2019. /* $ARB: B 72 GETSELECTED */
  2020. /// OK
  2021. void rx_getselected( struct RexxHost *host, struct rxd_getselected **rxd, long action, struct RexxMsg *rexxmsg )
  2022. {
  2023.    struct rxd_getselected *rd = *rxd;
  2024.    struct Mail **mlist;
  2025.  
  2026.    switch( action )
  2027.    {
  2028.       case RXIF_INIT:
  2029.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2030.          break;
  2031.          
  2032.       case RXIF_ACTION:
  2033.          if (mlist = MA_CreateMarkedList(G->MA->GUI.NL_MAILS))
  2034.          {
  2035.             int i;
  2036.             rd->res.num = calloc(1+(int)mlist[0], sizeof(long));
  2037.             for (i = 0; i < (int)mlist[0]; i++) rd->res.num[i] = (long *)&(mlist[i+2]->Position);
  2038.             free(mlist);
  2039.          }
  2040.          break;
  2041.       
  2042.       case RXIF_FREE:
  2043.          if (rd->res.num) free(rd->res.num);
  2044.          FreeVec( rd );
  2045.          break;
  2046.    }
  2047.    return;
  2048. }
  2049. ///
  2050. /* $ARB: E 72 GETSELECTED */
  2051.  
  2052. /* $ARB: B 73 ADDREDIT */
  2053. /// OK
  2054. void rx_addredit( struct RexxHost *host, struct rxd_addredit **rxd, long action, struct RexxMsg *rexxmsg )
  2055. {
  2056.    struct MUIS_Listtree_TreeNode *tn = NULL;
  2057.    struct rxd_addredit *rd = *rxd;
  2058.  
  2059.    switch( action )
  2060.    {
  2061.       case RXIF_INIT:
  2062.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2063.          break;
  2064.          
  2065.       case RXIF_ACTION:
  2066.          if (tn = (struct MUIS_Listtree_TreeNode *)DoMethod(G->AB->GUI.LV_ADRESSES, MUIM_Listtree_GetEntry, MUIV_Lt_GetEntry_ListNode_Active, MUIV_Lt_GetEntry_Position_Active, 0))
  2067.          {
  2068.             struct ABEntry *ab = (struct ABEntry *)(tn->tn_User);
  2069.             if (rd->arg.alias)    stccpy(ab->Alias, rd->arg.alias, SIZE_NAME);
  2070.             if (rd->arg.name)     stccpy(ab->RealName, rd->arg.name, SIZE_REALNAME);
  2071.             if (rd->arg.email)    stccpy(ab->Address, rd->arg.email, SIZE_ADDRESS);
  2072.             if (rd->arg.pgp)      stccpy(ab->PGPId, rd->arg.pgp, SIZE_ADDRESS);
  2073.             if (rd->arg.homepage) stccpy(ab->Homepage, rd->arg.homepage, SIZE_URL);
  2074.             if (rd->arg.street)   stccpy(ab->Street, rd->arg.street, SIZE_DEFAULT);
  2075.             if (rd->arg.city)     stccpy(ab->City, rd->arg.city, SIZE_DEFAULT);
  2076.             if (rd->arg.country)  stccpy(ab->Country, rd->arg.country, SIZE_DEFAULT);
  2077.             if (rd->arg.phone)    stccpy(ab->Phone, rd->arg.phone, SIZE_DEFAULT);
  2078.             if (rd->arg.comment)  stccpy(ab->Comment, rd->arg.comment, SIZE_DEFAULT);
  2079.             if (rd->arg.birthdate) ab->BirthDay = *rd->arg.birthdate;
  2080.             if (rd->arg.image)    stccpy(ab->Photo, rd->arg.image, SIZE_PATHFILE);
  2081.             if (rd->arg.member && ab->Type == AET_LIST)
  2082.             {
  2083.                char **p, *memb = AllocStrBuf(SIZE_DEFAULT);
  2084.                if (rd->arg.add && ab->Members) memb = StrBufCpy(memb, ab->Members);
  2085.                for (p = rd->arg.member; *p; p++) { memb = StrBufCat(memb, *p); memb = StrBufCat(memb, "\n"); }
  2086.                if (ab->Members) free(ab->Members);
  2087.                ab->Members = malloc(strlen(memb)+1);
  2088.                strcpy(ab->Members, memb);
  2089.                FreeStrBuf(memb);
  2090.             }
  2091.             DoMethod(G->AB->GUI.LV_ADRESSES, MUIM_List_Redraw, MUIV_List_Redraw_All);
  2092.             G->AB->Modified = TRUE;
  2093.          }
  2094.          else rd->rc = RETURN_ERROR;
  2095.          break;
  2096.       
  2097.       case RXIF_FREE:
  2098.          FreeVec( rd );
  2099.          break;
  2100.    }
  2101.    return;
  2102. }
  2103. ///
  2104. /* $ARB: E 73 ADDREDIT */
  2105.  
  2106. /* $ARB: B 74 ADDRDELETE */
  2107. /// OK
  2108. void rx_addrdelete( struct RexxHost *host, struct rxd_addrdelete **rxd, long action, struct RexxMsg *rexxmsg )
  2109. {
  2110.    struct rxd_addrdelete *rd = *rxd;
  2111.  
  2112.    switch( action )
  2113.    {
  2114.       case RXIF_INIT:
  2115.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2116.          break;
  2117.          
  2118.       case RXIF_ACTION:
  2119.          if (!AB_GotoEntry(rd->arg.alias)) rd->rc = RETURN_WARN;
  2120.          if (!rd->rc) AB_DeleteFunc();
  2121.          break;
  2122.       
  2123.       case RXIF_FREE:
  2124.          FreeVec( rd );
  2125.          break;
  2126.    }
  2127.    return;
  2128. }
  2129. ///
  2130. /* $ARB: E 74 ADDRDELETE */
  2131.  
  2132. /* $ARB: B 76 ADDRSAVE */
  2133. /// OK
  2134. void rx_addrsave( struct RexxHost *host, struct rxd_addrsave **rxd, long action, struct RexxMsg *rexxmsg )
  2135. {
  2136.    struct rxd_addrsave *rd = *rxd;
  2137.  
  2138.    switch( action )
  2139.    {
  2140.       case RXIF_INIT:
  2141.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2142.          break;
  2143.          
  2144.       case RXIF_ACTION:
  2145.          if (rd->arg.filename)
  2146.          {
  2147.             if (!AB_SaveTree(rd->arg.filename)) rd->rc = RETURN_ERROR;
  2148.          }
  2149.          else
  2150.          {
  2151.             if (AB_SaveTree(G->AB_Filename)) G->AB->Modified = FALSE; else rd->rc = RETURN_ERROR;
  2152.          }
  2153.          break;
  2154.       
  2155.       case RXIF_FREE:
  2156.          FreeVec( rd );
  2157.          break;
  2158.    }
  2159.    return;
  2160. }
  2161. ///
  2162. /* $ARB: E 76 ADDRSAVE */
  2163.  
  2164. /* $ARB: B 77 ADDRLOAD */
  2165. /// OK
  2166. void rx_addrload( struct RexxHost *host, struct rxd_addrload **rxd, long action, struct RexxMsg *rexxmsg )
  2167. {
  2168.    struct rxd_addrload *rd = *rxd;
  2169.  
  2170.    switch( action )
  2171.    {
  2172.       case RXIF_INIT:
  2173.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2174.          break;
  2175.          
  2176.       case RXIF_ACTION:
  2177.          if (!AB_LoadTree(rd->arg.filename, FALSE, FALSE)) rd->rc = RETURN_ERROR;
  2178.          break;
  2179.       
  2180.       case RXIF_FREE:
  2181.          FreeVec( rd );
  2182.          break;
  2183.    }
  2184.    return;
  2185. }
  2186. ///
  2187. /* $ARB: E 77 ADDRLOAD */
  2188.  
  2189. /* $ARB: B 79 ADDRGOTO */
  2190. /// OK
  2191. void rx_addrgoto( struct RexxHost *host, struct rxd_addrgoto **rxd, long action, struct RexxMsg *rexxmsg )
  2192. {
  2193.    struct rxd_addrgoto *rd = *rxd;
  2194.  
  2195.    switch( action )
  2196.    {
  2197.       case RXIF_INIT:
  2198.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2199.          break;
  2200.          
  2201.       case RXIF_ACTION:
  2202.          if (!AB_GotoEntry(rd->arg.alias)) rd->rc = RETURN_WARN;
  2203.          break;
  2204.       
  2205.       case RXIF_FREE:
  2206.          FreeVec( rd );
  2207.          break;
  2208.    }
  2209.    return;
  2210. }
  2211. ///
  2212. /* $ARB: E 79 ADDRGOTO */
  2213.  
  2214. /* $ARB: B 80 ADDRNEW */
  2215. /// OK
  2216. void rx_addrnew( struct RexxHost *host, struct rxd_addrnew **rxd, long action, struct RexxMsg *rexxmsg )
  2217. {
  2218.    static struct ABEntry addr;
  2219.    struct rxd_addrnew *rd = *rxd;
  2220.  
  2221.    switch( action )
  2222.    {
  2223.       case RXIF_INIT:
  2224.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2225.          break;
  2226.          
  2227.       case RXIF_ACTION:
  2228.          clear(&addr, sizeof(struct ABEntry));
  2229.          addr.Type = AET_USER;
  2230.          if (rd->arg.type) if (tolower(*rd->arg.type) == 'g') addr.Type = AET_GROUP;
  2231.                       else if (tolower(*rd->arg.type) == 'l') addr.Type = AET_LIST;
  2232.          if (rd->arg.alias)    stccpy(addr.Alias, rd->arg.alias, SIZE_NAME);
  2233.          if (rd->arg.name)     stccpy(addr.RealName, rd->arg.name, SIZE_REALNAME);
  2234.          if (rd->arg.email)    stccpy(addr.Address, rd->arg.email, SIZE_ADDRESS);
  2235.          if (!*addr.Alias) if (addr.Type == AET_USER) EA_SetDefaultAlias(&addr); else rd->rc = RETURN_ERROR;
  2236.          if (!rd->rc)
  2237.          {
  2238.             EA_FixAlias(&addr, FALSE);
  2239.             rd->res.alias = addr.Alias;
  2240.             EA_InsertBelowActive(&addr, addr.Type == AET_GROUP ? TNF_LIST : 0);
  2241.             G->AB->Modified = TRUE;
  2242.             AppendLogVerbose(71, GetStr(MSG_LOG_NewAddress), addr.Alias, "", "", "");
  2243.          }
  2244.          break;
  2245.       
  2246.       case RXIF_FREE:
  2247.          FreeVec( rd );
  2248.          break;
  2249.    }
  2250.    return;
  2251. }
  2252. ///
  2253. /* $ARB: E 80 ADDRNEW */
  2254.  
  2255. /* $ARB: B 81 MAILCHANGESUBJECT */
  2256. /// OK
  2257. void rx_mailchangesubject( struct RexxHost *host, struct rxd_mailchangesubject **rxd, long action, struct RexxMsg *rexxmsg )
  2258. {
  2259.    struct rxd_mailchangesubject *rd = *rxd;
  2260.    struct Mail **mlist;
  2261.    switch( action )
  2262.    {
  2263.       case RXIF_INIT:
  2264.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2265.          break;
  2266.          
  2267.       case RXIF_ACTION:
  2268.          if (mlist = MA_CreateMarkedList(G->MA->GUI.NL_MAILS))
  2269.          {
  2270.             int i, selected = (int)*mlist;
  2271.             for (i = 0; i < selected; i++) MA_ChangeSubject(mlist[i+2], rd->arg.subject);
  2272.             free(mlist);
  2273.             DoMethod(G->MA->GUI.NL_MAILS, MUIM_NList_Redraw, MUIV_NList_Redraw_All);
  2274.          }
  2275.          else rd->rc = RETURN_ERROR;
  2276.          break;
  2277.       
  2278.       case RXIF_FREE:
  2279.          FreeVec( rd );
  2280.          break;
  2281.    }
  2282.    return;
  2283. }
  2284. ///
  2285. /* $ARB: E 81 MAILCHANGESUBJECT */
  2286.  
  2287. /* $ARB: B 83 GETURL */
  2288. /// OK
  2289. void rx_geturl( struct RexxHost *host, struct rxd_geturl **rxd, long action, struct RexxMsg *rexxmsg )
  2290. {
  2291.    struct rxd_geturl *rd = *rxd;
  2292.    switch( action )
  2293.    {
  2294.       case RXIF_INIT:
  2295.          *rxd = AllocVec( sizeof *rd, MEMF_CLEAR );
  2296.          break;
  2297.          
  2298.       case RXIF_ACTION:
  2299.          if (TR_OpenTCPIP())
  2300.          {
  2301.             Busy(GetStr(MSG_TR_Downloading), "", 0, 0);
  2302.             if (!TR_DownloadURL(rd->arg.url, NULL, NULL, rd->arg.filename)) rd->rc = RETURN_ERROR;
  2303.             TR_CloseTCPIP();
  2304.             BusyEnd;
  2305.          }
  2306.          else rd->rc = RETURN_WARN;
  2307.          break;
  2308.       
  2309.       case RXIF_FREE:
  2310.          FreeVec( rd );
  2311.          break;
  2312.    }
  2313.    return;
  2314. }
  2315. ///
  2316. /* $ARB: E 83 GETURL */
  2317.  
  2318.  
  2319. #ifndef RX_ALIAS_C
  2320. char *ExpandRXCommand( struct RexxHost *host, char *command )
  2321. {
  2322.    /* Insert your ALIAS-HANDLER here */
  2323.    return( NULL );
  2324. }
  2325. #endif
  2326.  
  2327.